// 设置控制台编码为UTF-8以支持中文显示
const { setupConsoleEncoding } = require('../utils/encoding-utils');
setupConsoleEncoding();

const { ipcMain } = require('electron');
const axios = require('axios');

/**
 * 消息处理相关的 IPC 处理器
 * 管理与Ollama API的通信和流式响应处理
 */
class MessageHandlers {
  constructor() {
    this.currentConfig = null;
    this.sessionId = null; // 添加会话ID存储
    this.userId = null; // 添加用户ID存储
  }
  /**
   * 初始化消息处理器
   * @param {Object} config - 配置
   */
  initialize(config) {
    this.currentConfig = config;

    this.registerHandlers();
    // 不再需要监听 IPC 事件，因为现在使用直接调用
    console.log('消息处理器已初始化');
  }

  /**
   * 处理设置更新
   * @param {Object} event - 事件对象（可能为null，如果是直接调用）
   * @param {Object} updatedSettings - 更新后的设置
   */
  handleSettingsUpdate(event, updatedSettings) {
    console.log('=== MessageHandlers: 收到设置更新 ===');
    console.log('事件对象:', event ? '来自IPC' : '直接调用');
    console.log('更新的设置:', updatedSettings);

    try {
      // 检查是否有 Ollama API URL 相关的设置变更
      if (updatedSettings) {
        const oldConfig = this.currentConfig;
        this.currentConfig = updatedSettings;
        console.log('旧配置:', oldConfig);
        console.log('新配置已设置:', this.currentConfig);
      } else {
        console.log('警告: 接收到的设置为空');
      }
    } catch (error) {
      console.error('处理设置更新时出错:', error.message);
    }
    console.log('=== MessageHandlers: 设置更新处理完成 ===');
  }

  /**
   * 注册所有消息相关的 IPC 处理器
   */
  registerHandlers() {
    // 发送消息处理
    ipcMain.on('send-message', this.handleSendMessage.bind(this));
  }

  /**
   * 处理发送消息到Ollama API
   */
  async handleSendMessage(event, message) {
    try {
      // 显示正在处理的消息
      event.reply('ai-processing', true);      // 准备请求数据
      const currentModel = this.currentConfig.ollama.model;
      const requestData = {
        model: currentModel,
        prompt: message,
        stream: true,  // 修改为true以启用流式输出
        options: this.currentConfig.ollama.parameters,
        sessionId: this.generateSessionId(), // 添加会话ID
        userId: this.getCurrentUserId() // 添加用户ID
      };

      console.log(`发送请求到Ollama API (${currentModel}):`, message);

      // 显示模型正在思考的消息
      event.reply('ai-thinking', `正在使用 ${currentModel} 模型思考中...`);

      // 发送请求到Ollama API，使用流式响应
      const startTime = Date.now();

      const response = await axios({
        method: 'post',
        url: this.currentConfig.ollama.OLLAMA_BASE_URL + this.currentConfig.ollama.api.generate,
        data: requestData,
        responseType: 'stream'
      });

      let completeResponse = '';
      let thinkingText = '';
      let isThinking = true;
      let isFirstChunk = true;

      response.data.on('data', (chunk) => {
        try {
          const lines = chunk.toString().split('\n').filter(Boolean);

          for (const line of lines) {
            try {
              const data = JSON.parse(line);
              // 处理思考过程
              if (data.response && isFirstChunk) {
                isFirstChunk = false;
                // 移除"思考中"消息，开始显示真正的回复
                // event.reply('ai-thinking', null);
              }

              // 如果有思考过程，则显示
              if (data.response && data.response.startsWith('<think>')) {
                isThinking = true;
              }

              if (data.response && isThinking) {
                if (!data.response.startsWith('<think>') && !data.response.endsWith('</think>')) {
                  thinkingText += data.response;
                  event.reply('ai-thinking-stream', {
                    text: thinkingText,
                    done: false
                  });
                }
              }

              //处理返回信息
              if (data.response && !isThinking) {
                completeResponse += data.response;
                // 发送增量更新
                event.reply('ai-stream-response', {
                  text: completeResponse,
                  done: false
                });
              }

              if (data.response && data.response.endsWith('</think>')) {
                isThinking = false;
                event.reply('ai-thinking-stream', {
                  done: true
                });
              }

              // 检查是否是最后一个消息
              if (data.done) {
                const elapsedTime = ((Date.now() - startTime) / 1000).toFixed(2);
                console.log(`Ollama响应时间: ${elapsedTime}秒`);

                // 发送完整响应
                event.reply('ai-stream-response', {
                  done: true
                });
              }
            } catch (parseError) {
              console.error('解析JSON数据时出错:', parseError.message);
            }
          }
        } catch (chunkError) {
          console.error('处理数据块时出错:', chunkError.message);
        }
      });

      response.data.on('end', () => {
        console.log('Ollama流式响应结束');
        // 完成处理
        event.reply('ai-processing', false);
      });

      response.data.on('error', (error) => {
        console.error('Ollama流式响应错误:', error);
        event.reply('ai-response', `> ⚠️ 错误\n\n流式响应中发生错误: ${error.message}`);
        event.reply('ai-processing', false);
      });

    } catch (error) {
      console.error('Ollama API请求失败:', error.message);

      // 如果API请求失败，返回错误消息
      let errorMessage = '连接服务失败。';

      if (error.response) {
        errorMessage += `\n\n错误详情: ${error.response.status} ${error.response.statusText}`;
      } else if (error.request) {
        errorMessage += '\n\n无法连接到Ollama服务，请检查服务是否启动。';
      }

      event.reply('ai-response', `> ⚠️ 错误\n\n${errorMessage}`);
      event.reply('ai-processing', false);
    }
  }

  /**
   * 生成或获取当前会话ID
   * @returns {string} 会话ID
   */
  generateSessionId() {
    if (!this.sessionId) {
      this.sessionId = `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
    }
    return this.sessionId;
  }
  /**
   * 获取当前用户ID
   * @returns {string} 用户ID
   */
  getCurrentUserId() {
    if (!this.userId) {
      // 可以从配置文件、环境变量或其他方式获取用户ID
      this.userId = this.currentConfig?.userId || `user_${Date.now()}`;
    }
    return this.userId;
  }

  /**
   * 设置用户ID
   * @param {string} userId - 用户ID
   */
  setUserId(userId) {
    if (!userId || typeof userId !== 'string') {
      console.warn('MessageHandlers: 无效的用户ID，保持当前值');
      return;
    }
    
    const oldUserId = this.userId;
    this.userId = userId;
    
    console.log(`MessageHandlers: 用户ID已更新 ${oldUserId} -> ${userId}`);
    
    // 如果用户ID发生变化，可以选择重置会话
    if (oldUserId && oldUserId !== userId) {
      console.log('MessageHandlers: 用户ID变化，重置会话');
      this.resetSession();
    }
  }

  /**
   * 重置会话ID（可选，用于开始新对话时）
   */
  resetSession() {
    this.sessionId = null;
  }
}

// 导出单例实例
const messageHandlers = new MessageHandlers();
module.exports = messageHandlers;
